Crate cw_ownable

source ·
Expand description

CW Ownable

Utility for controlling ownership of CosmWasm smart contracts.

How to use

Initialize the owner during instantiation using the initialize_owner method provided by this crate:

use cosmwasm_std::{entry_point, DepsMut, Env, MessageInfo, Response};
use cw_ownable::OwnershipError;

#[entry_point]
pub fn instantiate(
    deps: DepsMut,
    env: Env,
    _info: MessageInfo,
    msg: InstantiateMsg,
) -> Result<Response<Empty>, OwnershipError> {
    cw_ownable::initialize_owner(deps.storage, deps.api, msg.owner.as_deref())?;
    Ok(Response::new())
}

Use the #[cw_ownable_execute] macro to extend your execute message:

use cosmwasm_schema::cw_serde;
use cw_ownable::cw_ownable_execute;

#[cw_ownable_execute]
#[cw_serde]
enum ExecuteMsg {
    Foo {},
    Bar {},
}

The macro inserts a new variant, UpdateOwnership to the enum:

#[cw_serde]
enum ExecuteMsg {
    UpdateOwnership(cw_ownable::Action),
    Foo {},
    Bar {},
}

Where Action can be one of three:

  • Propose to transfer the contract’s ownership to another account
  • Accept the proposed ownership transfer
  • Renounce the ownership, permanently setting the contract’s owner to vacant

Handle the messages using the update_ownership function provided by this crate:

use cosmwasm_std::{entry_point, DepsMut, Env, MessageInfo, Response};
use cw_ownable::{cw_serde, update_ownership, OwnershipError};

#[entry_point]
pub fn execute(
    deps: DepsMut,
    env: Env,
    info: MessageInfo,
    msg: ExecuteMsg,
) -> Result<Response, OwnershipError> {
    match msg {
        ExecuteMsg::UpdateOwnership(action) => {
            update_ownership(deps, &env.block, &info.sender, action)?;
        }
        _ => unimplemneted!(),
    }
    Ok(Response::new())
}

Use the #[cw_ownable_query] macro to extend your query message:

use cosmwasm_schema::{cw_serde, QueryResponses};
use cw_ownable::cw_ownable_query;

#[cw_ownable_query]
#[cw_serde]
#[derive(QueryResponses)]
pub enum QueryMsg {
    #[returns(FooResponse)]
    Foo {},
    #[returns(BarResponse)]
    Bar {},
}

The macro inserts a new variant, Ownership:

#[cw_serde]
#[derive(QueryResponses)]
enum ExecuteMsg {
    #[returns(Ownership<String>)]
    Ownership {},
    #[returns(FooResponse)]
    Foo {},
    #[returns(BarResponse)]
    Bar {},
}

Handle the message using the get_ownership function provided by this crate:

use cosmwasm_std::{entry_point, Deps, Env, Binary};
use cw_ownable::get_ownership;

#[entry_point]
pub fn query(deps: Deps, env: Env, msg: QueryMsg) -> StdResult<Binary> {
    match msg {
        QueryMsg::Ownership {} => to_binary(&get_ownership(deps.storage)?),
        _ => unimplemented!(),
    }
}

License

Contents of this crate at or prior to version 0.5.0 are published under GNU Affero General Public License v3 or later; contents after the said version are published under Apache-2.0 license.

Structs

Enums

  • Action
    Actions that can be taken to alter the contract’s ownership
  • Expiration
    Expiration represents a point in time when some event happens. It can compare with a BlockInfo and will return is_expired() == true once the condition is hit (and for every block in the future)
  • OwnershipError
    Errors associated with the contract’s ownership

Functions

  • assert_owner
    Assert that an account is the contract’s current owner.
  • get_ownership
    Get the current ownership value.
  • initialize_owner
    Set the given address as the contract owner.
  • is_owner
    Return Ok(true) if the contract has an owner and it’s the given address. Return Ok(false) if the contract doesn’t have an owner, of if it does but it’s not the given address. Return Err if fails to load ownership info from storage.
  • update_ownership
    Update the contract’s ownership info based on the given action. Return the updated ownership.

Attribute Macros